/**
 * 购物车状态管理
 */
import { defineStore } from 'pinia';
import { cartApi, productApi } from '@/api';
import { setStorage, getStorage } from '@/utils/storage';

export const useCartStore = defineStore('cart', {
  state: () => ({
    cartList: getStorage('cartList', []),
    selectedIds: []
  }),
  
  getters: {
    // 购物车商品总数
    cartCount(state) {
      return state.cartList.reduce((total, item) => total + item.count, 0);
    },
    
    // 已选中的商品数组
    selectedList(state) {
      return state.cartList.filter(item => state.selectedIds.includes(item.id));
    },
    
    // 已选中的商品数量
    selectedCount(state) {
      return state.selectedList.reduce((total, item) => total + item.count, 0);
    },
    
    // 已选中的商品总价
    selectedAmount(state) {
      return state.selectedList.reduce((total, item) => {
        // 接口返回的价格可能是字符串
        const price = parseFloat(item.price || item.details_price || 0);
        return total + item.count * price;
      }, 0).toFixed(2);
    },
    
    // 是否全选
    isAllSelected(state) {
      return state.cartList.length > 0 && state.selectedIds.length === state.cartList.length;
    }
  },
  
  actions: {
    // 获取购物车列表
    async getCartList() {
      try {
        const res = await cartApi.getCartList();
        // 假设返回的数据结构是 { code: number, msg: string, cart: Array }
        if (res.code === 200 && res.cart) {
          this.cartList = res.cart;
          this.selectedIds = this.cartList.map(item => item.id);
          
          // 持久化
          setStorage('cartList', this.cartList);
        }
        return res;
      } catch (error) {
        // 如果接口还未实现，使用本地数据
        console.log('使用本地购物车数据');
        this.cartList = getStorage('cartList', []);
        this.selectedIds = this.cartList.map(item => item.id);
        return Promise.reject(error);
      }
    },
    
    // 添加商品到购物车
    async addToCart(product) {
      try {
        // 检查购物车中是否已存在该商品
        const existItem = this.cartList.find(item => item.id === product.id);
        
        if (existItem) {
          // 如果已存在，增加数量
          await this.updateCartItem({
            id: product.id,
            count: existItem.count + (product.count || 1)
          });
        } else {
          // 不存在，添加新商品
          const newItem = {
            id: product.id,
            name: product.name || product.details_name,
            price: product.price || product.details_price,
            image: product.image || product.details_picurl,
            count: product.count || 1,
            selected: true
          };
          
          try {
            // 尝试调用接口
            const res = await cartApi.addToCart(newItem);
            if (res.code === 200) {
              // 接口调用成功
              this.cartList.unshift(res.cart_item || newItem);
              this.selectedIds.push(newItem.id);
            }
          } catch (error) {
            // 接口未实现，使用本地数据
            this.cartList.unshift(newItem);
            this.selectedIds.push(newItem.id);
          }
          
          // 持久化
          setStorage('cartList', this.cartList);
        }
        
        return true;
      } catch (error) {
        console.error('添加到购物车失败', error);
        return Promise.reject(error);
      }
    },
    
    // 更新购物车商品数量
    async updateCartItem({ id, count }) {
      if (!id) return false;
      
      try {
        try {
          // 尝试调用接口
          await cartApi.updateCartItem({ id, count });
        } catch (error) {
          console.log('接口未实现，使用本地数据更新');
        }
        
        // 更新本地购物车
        const index = this.cartList.findIndex(item => item.id === id);
        if (index !== -1) {
          this.cartList[index].count = count;
          
          // 持久化
          setStorage('cartList', this.cartList);
        }
        
        return true;
      } catch (error) {
        console.error('更新购物车失败', error);
        return Promise.reject(error);
      }
    },
    
    // 删除购物车商品
    async removeCartItem(ids) {
      if (!ids || (Array.isArray(ids) && ids.length === 0)) return false;
      
      try {
        const idsArr = Array.isArray(ids) ? ids : [ids];
        
        try {
          // 尝试调用接口
          await cartApi.removeCartItem(idsArr);
        } catch (error) {
          console.log('接口未实现，使用本地数据删除');
        }
        
        // 更新本地购物车
        this.cartList = this.cartList.filter(item => !idsArr.includes(item.id));
        this.selectedIds = this.selectedIds.filter(id => !idsArr.includes(id));
        
        // 持久化
        setStorage('cartList', this.cartList);
        
        return true;
      } catch (error) {
        console.error('删除购物车商品失败', error);
        return Promise.reject(error);
      }
    },
    
    // 清空购物车
    async clearCart() {
      try {
        try {
          // 尝试调用接口
          await cartApi.clearCart();
        } catch (error) {
          console.log('接口未实现，使用本地数据清空');
        }
        
        // 更新本地购物车
        this.cartList = [];
        this.selectedIds = [];
        
        // 持久化
        setStorage('cartList', this.cartList);
        
        return true;
      } catch (error) {
        console.error('清空购物车失败', error);
        return Promise.reject(error);
      }
    },
    
    // 选中/取消选中单个商品
    toggleSelect(id) {
      if (!id) return;
      
      const index = this.selectedIds.indexOf(id);
      if (index === -1) {
        this.selectedIds.push(id);
      } else {
        this.selectedIds.splice(index, 1);
      }
    },
    
    // 全选/取消全选
    toggleSelectAll() {
      if (this.isAllSelected) {
        this.selectedIds = [];
      } else {
        this.selectedIds = this.cartList.map(item => item.id);
      }
    },
    
    // 购买商品
    async buyProduct(product) {
      try {
        const data = {
          id: product.id,
          num: product.count || 1,
          code: 1 // 下单状态，根据API文档
        };
        
        const res = await productApi.buyProduct(data);
        return res;
      } catch (error) {
        console.error('购买商品失败', error);
        return Promise.reject(error);
      }
    }
  }
}); 